/*
 * TestBlockSorting.cpp
 *
 *  Created on: 27/05/2014
 *      Author: manuel
 */

#include "TestBlockSorting.h"

TestBlockSorting::TestBlockSorting() {}

TestBlockSorting::~TestBlockSorting() {}

bool testCodificarYDecodificarBloqueCorrectamente(){
//	Archivo archivo("harrypotter2.txt");
//	unsigned int tamano_bloque = 1024; // tamanio en bytes
//	unsigned short n_optimiz = 9; // n-1 caracteres agregados para la optimizacion
//	//unsigned int n_optimiz2 = 9; // n-1 caracteres agregados para la optimizacion
//
//	Bloque bloqueOriginal(tamano_bloque);
//
//	BlockSorting bs;
//
//	//index del bloque original en la matriz de rotaciones
//	unsigned short INDEX;
//
//	archivo.abrir();
//	archivo.leerBloque(bloqueOriginal);
//	archivo.cerrar();
//
//	Bloque bloqueCodif(tamano_bloque);
//
//	bs.codificarBloque(bloqueOriginal.getData(), bloqueOriginal.getTamano(), bloqueCodif.getData(), INDEX, n_optimiz);
//
//	Bloque bloqueIdx( sizeof(INDEX) );
//	memcpy(bloqueIdx.getData(), (unsigned char*)&INDEX, 2);
//	//printf("%c,%c\n",bloqueIdx.getData()[0], bloqueIdx.getData()[1]);
//
//	Archivo codificado("codificado.txt");
//	codificado.abrir();
//	codificado.escribirBloque(bloqueCodif);
//	codificado.escribirBloque(bloqueIdx);
//	codificado.cerrar();
//
//	Bloque bloqueDecodif(tamano_bloque);
//	bs.decodificarBloque(bloqueCodif.getData(), INDEX, bloqueDecodif.getData(), bloqueDecodif.getTamano());
//
//	Archivo decodificado("decodificado.txt");
//	decodificado.abrir();
//	decodificado.escribirBloque(bloqueDecodif);
//	decodificado.cerrar();
//
//	int diff = memcmp( bloqueOriginal.getData(), bloqueDecodif.getData(), bloqueOriginal.getTamano());
//
//	if( diff == 0 )
//		return PASA;

	return FALLA;
}

bool testCodificarYDecodificarArchivoCorrectamente() {
//
//	unsigned int tamano_bloque = 1024; // tamanio en bytes
//	unsigned short n_optimiz = 9; // n-1 caracteres agregados para la optimizacion
//
//	//  archivo_codificado = [BLOQUE_0|INDEX_0|BLOQUE_1|INDEX_1|BLOQUE_2|INDEX_2|...]
//	Bloque bloqueArchivo(tamano_bloque); // bloque del archivo original/codificado
//	Bloque bloqueCodif(tamano_bloque); // bloque codificado
//	Bloque bloqueDecodif(tamano_bloque); // bloque decodificado
//
//	unsigned short idx;
//	Bloque bloqueIndex( sizeof(idx) ); // para guardar los indexs de cada bloque
//
//	Archivo archivo("harrypotter2.txt");
//	Archivo codificado("archivo_codificado.txt");
//	Archivo decodificado("archivo_decodificado.txt");
//
//	archivo.abrir();
//	codificado.abrir();
//
//	BlockSorting bs;
//	std::cout << "CODIFICA ARCHIVO\n";
//	while( archivo.leerBloque(bloqueArchivo) ){
//
//		bs.codificarBloque(bloqueArchivo.getData(), bloqueArchivo.getTamano(), bloqueCodif.getData(), idx, n_optimiz);
//
//		memcpy(bloqueIndex.getData(), (const unsigned char*) &idx, 2);
//
//		codificado.escribirBloque(bloqueCodif);
//		codificado.escribirBloque(bloqueIndex);
//
//		bloqueArchivo.iniciar();
//		bloqueCodif.iniciar();
//	}
//
//	unsigned int tam_bloque_final = strlen((char*)bloqueArchivo.getData());
//
//	Bloque bloqueFinal(tam_bloque_final);
//
//	/// procesamos los ultimos bytes que no llegan a completar 1 bloque ////////////
//
//	bs.codificarBloque(bloqueArchivo.getData(), tam_bloque_final, bloqueCodif.getData(), idx, n_optimiz);
//
//	memcpy(bloqueIndex.getData(), (const unsigned char*) &idx, 2);
//	memcpy(bloqueFinal.getData(), bloqueCodif.getData(), tam_bloque_final);
//
//	codificado.escribirBloque(bloqueFinal);
//	codificado.escribirBloque(bloqueIndex);
//
//	bloqueArchivo.iniciar();
//	bloqueCodif.iniciar();
//	///////////////////////////////////////////////////////////////////////////////
//
//	archivo.cerrar();
//	codificado.cerrar();
//
//	codificado.abrir();
//	decodificado.abrir();
//
//	std::cout << "DECODIFICA ARCHIVO\n";
//	while( codificado.leerBloque(bloqueCodif) && codificado.leerBloque(bloqueIndex) ){
//
//		memcpy( (unsigned char*) &idx, bloqueIndex.getData(), 2);
//
//		bs.decodificarBloque(bloqueCodif.getData(), idx, bloqueDecodif.getData(), bloqueCodif.getTamano());
//
//		decodificado.escribirBloque(bloqueDecodif);
//
//		bloqueCodif.iniciar();
//	}
//
//	/// procesamos los ultimos bytes que no llegan a completar 1 bloque ////////////
//
//	memcpy( &idx, &bloqueCodif.getData()[bloqueFinal.getTamano()], 2);
//
//	bloqueFinal.iniciar();
//	bloqueDecodif.iniciar();
//
//	bs.decodificarBloque(bloqueCodif.getData(), idx, bloqueDecodif.getData(), bloqueFinal.getTamano());
//
//	memcpy(bloqueFinal.getData(), bloqueDecodif.getData(), bloqueFinal.getTamano());
//
//	decodificado.escribirBloque(bloqueFinal);
//
//	///////////////////////////////////////////////////////////////////////////////
//
//	codificado.cerrar();
//	decodificado.cerrar();

	return PASA;
}

bool testCodificarYDecodificarArchivoCorrectamente2() {

	BlockSorting bs(1024, 20);

	std::string archivo_decodificado = bs.codificarArchivo("book2");

	bs.decodificarArchivo(archivo_decodificado.c_str());

	return PASA;
}

void TestBlockSorting::correrTests(){
//	std::cout << "TestBlockSorting:" << std::endl;
//	if( testCodificarYDecodificarBloqueCorrectamente() == PASA ){
//		std::cout << "BS codifica y decodifica correctamente OK" << std::endl;
//	}else{
//		std::cout << "BS codifica y decodifica correctamente FAIL" << std::endl;
//	}

//	if( testCodificarYDecodificarArchivoCorrectamente() == PASA ){
//		std::cout << "BS codifica y decodifica correctamente OK\nVerificar haciendo: diff -a archivo_decodificado.txt harrypotter2.txt" << std::endl;
//	}else{
//		std::cout << "BS codifica y decodifica correctamente FAIL" << std::endl;
//	}

	if( testCodificarYDecodificarArchivoCorrectamente2() == PASA ){
		std::cout << "BS codifica y decodifica correctamente OK\n"
				"Verificar haciendo: diff -a <nombre-archivo>.decod.BS <nombre-archivo>" << std::endl;
	}else{
		std::cout << "BS codifica y decodifica correctamente FAIL" << std::endl;
	}
}

